#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>

//typedef struct {
//	Queue _q1;
//	Queue _q2;
//} MyStack;
//
///** Initialize your data structure here. */
//
//MyStack* myStackCreate() {
//	MyStack *st = (MyStack*)malloc(sizeof(MyStack));
//	QueueInit(&(st->_q1));
//	QueueInit(&(st->_q2));
//
//	return st;
//}
//
///** Push element x onto stack. */
//void myStackPush(MyStack* obj, int x) {
//	if (!QueueEmpty(&obj->_q1))
//	{
//		QueuePush(&obj->_q1, x);
//	}
//	else
//	{
//		QueuePush(&obj->_q2, x);
//	}
//
//
//}
//
///** Removes the element on top of the stack and returns that element. */
//int myStackPop(MyStack* obj) {
//	Queue* empty = &obj->_q1;
//	Queue* nonEmpty = &obj->_q2;
//	if (QueueEmpty(&obj->_q2))
//	{
//		empty = &obj->_q2;
//		nonEmpty = &obj->_q1;
//	}
//
//	while (QueueSize(nonEmpty) > 1)
//	{
//		QueuePush(empty, QueueFront(nonEmpty));
//		QueuePop(nonEmpty);
//	}
//
//	int top = QueueFront(nonEmpty);
//	QueuePop(nonEmpty);
//	return top;
//}
//
///** Get the top element. */
//int myStackTop(MyStack* obj) {
//	if (!QueueEmpty(&obj->_q1))
//	{
//		return QueueBack(&obj->_q1);
//	}
//	else
//	{
//		return QueueBack(&obj->_q2);
//	}
//}
//
///** Returns whether the stack is empty. */
//bool myStackEmpty(MyStack* obj) {
//	return QueueEmpty(&obj->_q1) && QueueEmpty(&obj->_q2);
//}
//
//void myStackFree(MyStack* obj) {
//	QueueDestroy(&obj->_q1);
//	QueueDestroy(&obj->_q2);
//
//	free(obj);
//}

//typedef struct {
//	Stack _pushST;
//	Stack _popST;
//} MyQueue;
//
///** Initialize your data structure here. */
//
//MyQueue* myQueueCreate() {
//	MyQueue* pq = (MyQueue*)malloc(sizeof(MyQueue));
//	StackInit(&pq->_pushST);
//	StackInit(&pq->_popST);
//	return pq;
//}
//
///** Push element x to the back of queue. */
//void myQueuePush(MyQueue* obj, int x) {
//	StackPush(&obj->_pushST, x);
//}
//
///** Removes the element from in front of queue and returns that element. */
//int myQueuePop(MyQueue* obj) {
//	int top = myQueuePeek(obj);
//	StackPop(&obj->_popST);
//	return top;
//}
//
///** Get the front element. */
//int myQueuePeek(MyQueue* obj)
//{
//	if (StackEmpty(&obj->_popST))
//	{
//		while (!StackEmpty(&obj->_pushST))
//		{
//			StackPush(&obj->_popST, StackTop(&obj->_pushST));
//			StackPop(&obj->_pushST);
//		}
//		return StackTop(&obj->_popST);
//	}
//	else
//	{
//		return StackTop(&obj->_popST);
//	}
//}
//
///** Returns whether the queue is empty. */
//bool myQueueEmpty(MyQueue* obj) {
//	return StackEmpty(&obj->_popST) && StackEmpty(&obj->_pushST);
//}
//
//void myQueueFree(MyQueue* obj) {
//	StackDestroy(&obj->_popST);
//	StackDestroy(&obj->_pushST);
//	free(obj);
//}
//
//typedef struct {
//	int* _data;
//	int _front;
//	int _rear;
//	int _k
//
//} MyCircularQueue;
//
//bool myCircularQueueIsEmpty(MyCircularQueue* obj);
//bool myCircularQueueIsFull(MyCircularQueue* obj);
//
//MyCircularQueue* myCircularQueueCreate(int k) {
//	MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
//	obj->_data = (int*)malloc(sizeof(int)*(k + 1));
//	obj->_front = obj->_rear = 0;
//	obj->_k = k;
//	return obj;
//}
//
//bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
//	if (myCircularQueueIsFull(obj))
//	{
//		return false;
//	}
//	obj->_data[obj->_rear] = value;
//	obj->_rear++;
//	obj->_rear %= (obj->_k + 1);
//	return true;
//}
//
//bool myCircularQueueDeQueue(MyCircularQueue* obj) {
//	if (myCircularQueueIsEmpty(obj))
//	{
//		return false;
//	}
//	obj->_front++;
//	obj->_front %= (obj->_k + 1);
//	return true;
//}
//
//int myCircularQueueFront(MyCircularQueue* obj) {
//	if (myCircularQueueIsEmpty(obj))
//	{
//		return -1;
//	}
//	return obj->_data[obj->_front];
//}
//
//int myCircularQueueRear(MyCircularQueue* obj) {
//	if (myCircularQueueIsEmpty(obj))
//	{
//		return -1;
//	}
//	int rear = obj->_rear - 1;
//	if (rear == -1)
//		rear = obj->_k;
//	return obj->_data[rear];
//}
//
//bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
//	return obj->_front == obj->_rear;
//}
//
//bool myCircularQueueIsFull(MyCircularQueue* obj) {
//	return (obj->_rear + 1) % (obj->_k + 1) == obj->_front;
//}
//
//void myCircularQueueFree(MyCircularQueue* obj) {
//	free(obj->_data);
//	free(obj);
//}